package com.mgkj.controller.WMS;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.mgkj.annotation.Log;
import com.mgkj.common.result.Result;
import com.mgkj.config.Recordable;
import com.mgkj.dto.*;

import com.mgkj.dto.MOCTGDto;
import com.mgkj.dto.yf.*;
import com.mgkj.entity.*;
import com.mgkj.entity.InvBarcodeOperation;
import com.mgkj.entity.yf.InitMocta;
import com.mgkj.mapper.*;
import com.mgkj.service.*;
import com.mgkj.vo.*;
import com.mgkj.vo.yf.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.formula.functions.T;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

/**
 * @author yyyjcg
 * @date 2024/3/8
 * @Description
 */
@Slf4j
@RestController
@Api(tags = "工单管理相关接口")
@CrossOrigin
@RequestMapping("/api/MO")
public class MoController {
    @Resource
    private CommonService commonService;

    @Autowired
    private MoService moService;

    @Autowired
    private MoMapper moMapper;

    @Autowired
    private LogisticsRemoteService logisticsRemoteService;


    @Resource
    private MaterialRequisitionService materialRequisitionService;

    @Resource
    private MoctaMapper moctaMapper;

    @Resource
    private InitCmsmqMapper cmsmqMapper;

    @Resource
    private InitCmsmdMapper cmsmdMapper;

    @Resource
    private MoctcService moctcService;

    @Resource
    private DeliveryNoticeMapper deliveryNoticeMapper;

    @Resource
    private InvmbMapper invmbMapper;
    @Resource
    private MoctgMapper moctgMapper;
    @Resource
    private MoctfMapper moctfMapper;
    @Resource
    private WmsInvmlMapper wmsInvmlMapper;
    @Resource
    private WmsInvlaMapper wmsInvlaMapper;
//    ===================================================转为abl流程的前端，后端尽量不动=============================================
//=======================================================易飞-根据工单生成领料单=====================================================
    @ApiOperation("获取领料单身为为未审核的领料单")
    @PostMapping("/getIssueReceiptReq")
    public Result<?> getIssueReceiptReq(@RequestBody IssueReceiptReqDto pageDTO){
        //扫过来的单号D开头则
        String docNo = pageDTO.getDocNo();
        if (docNo != null && docNo.startsWith("D")) {
            //查工单号
            String[] split = docNo.split("-");

            if (split.length != 2) {
                return Result.fail().message("单号格式错误：" +docNo);
            }

            String db = split[0]; // 单别
            String dh = split[1]; // 单号

            docNo = moMapper.selectDocNo(db, dh);
            pageDTO.setDocNo(docNo);
        }
        List<IssueReceiptReqVo> list = moMapper.getIssueReceiptReq(pageDTO);
        if (!list.isEmpty()) {
            // 使用Stream处理合并逻辑
            List<NewIssueReceiptReqVo> mergedList = list.stream()
                    // 按docNo分组
                    .collect(Collectors.groupingBy(
                            IssueReceiptReqVo::getDocNo,
                            Collectors.toList()
                    ))
                    .entrySet().stream()
                    .map(entry -> {
                        // 获取当前分组的Vo列表
                        List<IssueReceiptReqVo> groupItems = entry.getValue();
                        // 取第一个元素作为公共字段来源
                        IssueReceiptReqVo firstItem = groupItems.get(0);

                        // 创建合并后的Vo对象
                        NewIssueReceiptReqVo newVo = new NewIssueReceiptReqVo();
                        newVo.setWorkCenterCode(firstItem.getWorkCenterCode());
                        newVo.setWorkCenterName(firstItem.getWorkCenterName());
                        newVo.setDocNo(entry.getKey()); // 领料单号来自分组键
                        newVo.setDocDate(firstItem.getDocDate());
                        newVo.setWarehouseCode(firstItem.getWarehouseCode());
                        newVo.setWarehouseName(firstItem.getWarehouseName());

                        // 收集所有品号 用/分隔
                        String itemCodesStr = groupItems.stream()
                                .map(IssueReceiptReqVo::getItemCode)
                                .distinct() // 去重
                                .collect(Collectors.joining("/"));
                        newVo.setItemCode(itemCodesStr);

                        // 收集所有品名 用/分隔
                        String itemNamesStr = groupItems.stream()
                                .map(IssueReceiptReqVo::getItemName)
                                .distinct() // 去重
                                .collect(Collectors.joining("/"));
                        newVo.setItemName(itemNamesStr);

                        // 收集所有工单号并去重
                        List<String> moDocNos = groupItems.stream()
                                .map(IssueReceiptReqVo::getModocNo)
                                .distinct() // 去重
                                .collect(Collectors.toList());
                        newVo.setMoDocNoList(moDocNos);

//                        // 收集所有客户单号并去重
//                        List<String> customerNos = groupItems.stream()
//                                .map(IssueReceiptReqVo::getCustomerNo)
//                                .distinct()
//                                .collect(Collectors.toList());
//                        newVo.setCustomerNo(customerNos);

                        return newVo;
                    })
                    .collect(Collectors.toList());
            // 领料单一致的直接合并
            HashMap<String, Object> result = new HashMap<>();
            result.put("total", mergedList.size());
            result.put("list", mergedList);
            return Result.ok(result);
        }
        return Result.fail().message("未查询到领料单信息！");

    }

    @PostMapping("/getIssueReceiptWarehouse")
    @ApiOperation(value = "获取发货仓库信息")
    public Result getIssueReceiptWarehouse(@RequestBody List<String> docNoList) {
        List<IssueReceiptWarehouse> issueReceiptWarehouseList = moMapper.getIssueReceiptWarehouseList(docNoList);
        if (issueReceiptWarehouseList.isEmpty()) {
            return Result.fail().message("未查询到仓库信息！");
        }
        return Result.ok(issueReceiptWarehouseList);
    }

    @ApiOperation("根据领料申请单和仓库编号查出库明细")
    @PostMapping("/getIssueReceiptReqD")
    public Result selectListMoInStorageByBarcode(@RequestBody IssueReceiptReqDDto dto){

        //查最新数据
        List<issueReceiptReqDVo> list = moMapper.getIssueReceiptReqD(dto);
        if(list.isEmpty()){
            return Result.fail().message("未查询到库明细信息！");
        }
        // 按 itemCode 分组合并（处理 customerNo/DemandNo 拼接）
        Map<String, issueReceiptReqDVo> mergedMap = list.stream()

                .collect(Collectors.toMap(
                        issueReceiptReqDVo::getItemCode,
                        vo -> {
                            // 创建新对象并初始化字段
                            issueReceiptReqDVo merged = new issueReceiptReqDVo();
                            merged.setItemCode(vo.getItemCode());
                            merged.setItemName(vo.getItemName());
                            merged.setItemSpec(vo.getItemSpec());
                            merged.setWarehouseCode(vo.getWarehouseCode());
                            merged.setBinCode(vo.getBinCode());
                            merged.setUnitCode(vo.getUnitCode());
                            merged.setUnitName(vo.getUnitName());
                            merged.setDocNo(vo.getDocNo());
                            merged.setShjg(vo.getShjg());
                            merged.setCustomerNo(vo.getCustomerNo());

                            // 初始化 customerNo 和 DemandNo（去重并拼接）
                            merged.setCustomerNo(vo.getCustomerNo() != null ? vo.getCustomerNo() : "");
                            merged.setDemandNo(vo.getDemandNo() != null ? vo.getDemandNo() : "");

                            // 初始化数值字段（防 Null）
                            merged.setRequestQty(vo.getRequestQty() != null ? vo.getRequestQty() : BigDecimal.ZERO);
                            merged.setIssueReceiptQty(vo.getIssueReceiptQty() != null ? vo.getIssueReceiptQty() : BigDecimal.ZERO);
                            merged.setCurrectNum(vo.getCurrectNum() != null ? vo.getCurrectNum() : BigDecimal.ZERO);

                            return merged;
                        },
                        //Collectors.toMap的合并函数（mergeFunction）, 流中出现重复的键（相同itemCode）时，mergeFunction会被调用，决定如何合并这两个值
                        (vo1, vo2) -> {
                            // 合并 customerNo 去重
                            Set<String> customerNos = new TreeSet<>();
                            if (vo1.getCustomerNo() != null && !vo1.getCustomerNo().isEmpty()) {
                                customerNos.addAll(Arrays.asList(vo1.getCustomerNo().split("/")));
                            }
                            if (vo2.getCustomerNo() != null && !vo2.getCustomerNo().isEmpty()) {
                                customerNos.addAll(Arrays.asList(vo2.getCustomerNo().split("/")));
                            }
                            vo1.setCustomerNo(String.join("/", customerNos));

                            // 合并 DemandNo 去重
                            Set<String> demandNos = new TreeSet<>();
                            if (vo1.getDemandNo() != null && !vo1.getDemandNo().isEmpty()) {
                                demandNos.addAll(Arrays.asList(vo1.getDemandNo().split("/")));
                            }
                            if (vo2.getDemandNo() != null && !vo2.getDemandNo().isEmpty()) {
                                demandNos.addAll(Arrays.asList(vo2.getDemandNo().split("/")));
                            }
                            vo1.setDemandNo(String.join("/", demandNos));

                            // 数值字段求和
                            vo1.setRequestQty(addBigDecimals(vo1.getRequestQty(), vo2.getRequestQty()));
                            vo1.setIssueReceiptQty(addBigDecimals(vo1.getIssueReceiptQty(), vo2.getIssueReceiptQty()));
                            vo1.setCurrectNum(addBigDecimals(vo1.getCurrectNum(), vo2.getCurrectNum()));

                            return vo1;
                        }
                ));

        // 提取合并结果
        List<issueReceiptReqDVo> mergedList = new ArrayList<>(mergedMap.values());
//        for (issueReceiptReqDVo detail : mergedList) {
//            // 保存到领料明细汇总表 picking_summary
//            int i = moMapper.savePickingSummary(detail, dto.getCreateBy());
//            Double num = moMapper.queryInventory(detail.getItemCode());
//            detail.setInventoryNum(num);
//            if (i <= 0) {
//                return Result.fail(list).message(" 保存到领料明细汇总表失败！");
//            }
//        }
        return Result.ok(mergedList);
    }

    private BigDecimal addBigDecimals(BigDecimal num1, BigDecimal num2) {
        return (num1 == null ? BigDecimal.ZERO : num1)
                .add(num2 == null ? BigDecimal.ZERO : num2);
    }


    @ApiOperation("领料下架-提交-维护工单(已审核)->领料申请单(已审核)->生成领料出库单(已审核)")
    @PostMapping("/IssueReceiptSubmit")
    @Log("领料下架-提交-维护工单(已审核)->领料申请单(已审核)->生成领料出库单(已审核)")
    public Result IssueReceiptSubmit(@RequestBody MoIssueReceiptDto dto){
        //工作中心不可为空白，且需要是同一工作中心的工单生成领料单
        String db = dto.getSingle();
        LocalDateTime currentTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");


        String creator = dto.getCreateBy();
        String gzzx ;
        String deptNo ;
        //获取工单列表第一个工单-同工作中心
        String firstNo = dto.getList().get(0).getDocNo();
        gzzx = moMapper.selectWorkCenter(firstNo.split("-")[0],firstNo.split("-")[1]);

        LldDto lldDto = new LldDto();
        lldDto.setCreator(creator);
        lldDto.setDb(db);
        lldDto.setGcbh("1000");
        lldDto.setCompany("ZJQH");
        lldDto.setGzzx(gzzx);
        String rq = currentTime.format(formatter);
        lldDto.setCreator(dto.getCreateBy());
        lldDto.setRq(rq);
//        llddto.setDeptNo(deptNo);

        List<LldList> lldListList = new ArrayList<>();
        for (MoIssueReceiptSubmitDto list : dto.getList()) {
            //获取工单列表，查询对应工单数据，组建领料单身
            String moNo = list.getDocNo();
            String gddb = moNo.split("-")[0];
            String gddh = moNo.split("-")[1];

            InitMocta mocta = moMapper.selectMocta(gddb,gddh);

            LldList lldList = new LldList();
            lldList.setGddb(gddb);
            lldList.setGddh(gddh);
            lldList.setCpph(mocta.getTa006());
            lldList.setCppm(mocta.getTa034());
            lldList.setCpgg(mocta.getTa035());
//            lldList.setGyss(dto.getWorkOrderSeq());//工艺顺序
            lldList.setXlyl(list.getRequestQty().toString());//需领用量
            lldList.setTlyl(list.getIssueReceiptQty().toString());//已领用量
            Double wlyl = list.getRequestQty().doubleValue() -  list.getIssueReceiptQty().doubleValue();
            lldList.setWlyl(wlyl.toString());//未领用量
//            lldList.setLx("54");
            lldList.setWlbh(list.getItemCode());//物料编号
            lldList.setQtw(list.getQty());//领料/退料数量
            lldList.setLotNumber(list.getLotNumber());//批号
            lldList.setBinCode(list.getBinCode());//库位编号
            lldList.setWarehouseCode(list.getWarehouseCode());//库位编号
            lldList.setRemark("");
            lldList.setKwInfo(list.getKwInfo());
            lldListList.add(lldList);

        }

        lldDto.setList(lldListList);
        Result<T> result = materialRequisitionService.add(lldDto);
        if (result.getCode() != 200){
            return Result.fail().message(result.getMessage());
        }
        return Result.ok(result.getData());
    }



    @ApiOperation("领料出库-查看领料单单据性质")
    @GetMapping("/lldList")
    public Result lldList(){
        List<CmsmqVo> list = cmsmqMapper.selectLldVo();
        return  Result.ok(list);
    }

    @ApiOperation("查看品号/批号/库存")
    @GetMapping("/itemList/{itemCode}/{warehouseCode}")
    public Result itemList(@PathVariable String itemCode, @PathVariable String warehouseCode) {
        // 使用获取到的路径参数查询数据
        List<itemVo> list = deliveryNoticeMapper.selectItemVo(itemCode, warehouseCode);
        return Result.ok(list);
    }

    @ApiOperation("查看该品在wms中的库位做指引展示")
    @GetMapping("/wmsInvmlList/{itemCode}/{warehouseCode}")
    public Result wmsInvmlList(@PathVariable String itemCode, @PathVariable String warehouseCode) {
        // 使用获取到的路径参数查询数据
        List<WmsInvml> list = deliveryNoticeMapper.selectWmsInvmlList(itemCode, warehouseCode);
        return Result.ok(list);
    }



//=================================================易飞-根据领料单更新领料单=========================================//
    @ApiOperation("领料出库-查询领料单单身")
    @PostMapping("/listMoctcBody")
    @Log("领料出库-查询领料单单身")
    public Result listMoctcBody(@RequestBody listMoctcDto dto){
        PageHelper.startPage(dto.getPage(), dto.getPageSize());
        List<listMoctcVo> list = moctaMapper.selectListMoctcBody(dto);

        PageInfo<listMoctcVo> pageInfo = new PageInfo<>(list);
        return Result.ok(pageInfo);
    }

//    @ApiOperation("领料出库-abl查询领料单单头")
//    @PostMapping("/listMoctcBody")
//    public Result listMoctcBody(@RequestBody listMoctcDto dto) {
//        PageHelper.startPage(dto.getPage(), dto.getPageSize());
//        List<listMoctcVo> list = moctaMapper.selectListMoctc(dto);
//        List<IssueReceiptReqVo> list = moMapper.getIssueReceiptReq(pageDTO);
//        if (!list.isEmpty()) {
//            // 使用Stream处理合并逻辑
//            List<NewIssueReceiptReqVo> mergedList = list.stream()
//                    // 按docNo分组
//                    .collect(Collectors.groupingBy(
//                            IssueReceiptReqVo::getDocNo,
//                            Collectors.toList()
//                    ))
//                    .entrySet().stream()
//                    .map(entry -> {
//                        // 获取当前分组的Vo列表
//                        List<IssueReceiptReqVo> groupItems = entry.getValue();
//                        // 取第一个元素作为公共字段来源
//                        IssueReceiptReqVo firstItem = groupItems.get(0);
//
//                        // 创建合并后的Vo对象
//                        NewIssueReceiptReqVo newVo = new NewIssueReceiptReqVo();
//                        newVo.setWorkCenterCode(firstItem.getWorkCenterCode());
//                        newVo.setWorkCenterName(firstItem.getWorkCenterName());
//                        newVo.setDocNo(entry.getKey()); // 领料单号来自分组键
//                        newVo.setDocDate(firstItem.getDocDate());
//                        newVo.setWarehouseCode(firstItem.getWarehouseCode());
//                        newVo.setWarehouseName(firstItem.getWarehouseName());
//
//                        // 收集所有品号 用/分隔
//                        String itemCodesStr = groupItems.stream()
//                                .map(IssueReceiptReqVo::getItemCode)
//                                .distinct() // 去重
//                                .collect(Collectors.joining("/"));
//                        newVo.setItemCode(itemCodesStr);
//
//                        // 收集所有品名 用/分隔
//                        String itemNamesStr = groupItems.stream()
//                                .map(IssueReceiptReqVo::getItemName)
//                                .distinct() // 去重
//                                .collect(Collectors.joining("/"));
//                        newVo.setItemName(itemNamesStr);
//
//                        // 收集所有工单号并去重
//                        List<String> moDocNos = groupItems.stream()
//                                .map(IssueReceiptReqVo::getModocNo)
//                                .distinct() // 去重
//                                .collect(Collectors.toList());
//                        newVo.setMoDocNoList(moDocNos);
//
////                        // 收集所有客户单号并去重
////                        List<String> customerNos = groupItems.stream()
////                                .map(IssueReceiptReqVo::getCustomerNo)
////                                .distinct()
////                                .collect(Collectors.toList());
////                        newVo.setCustomerNo(customerNos);
//
//                        return newVo;
//                    })
//                    .collect(Collectors.toList());
//            // 领料单一致的直接合并
//            HashMap<String, Object> result = new HashMap<>();
//            result.put("total", mergedList.size());
//            result.put("list", mergedList);
//            return Result.ok(result);
//        }
//    }

    @Recordable
    @ApiOperation("更新领料单")
    @Log("更新领料单")
    @PostMapping("/updatemoctc")
    public Result updatemoctc(@RequestBody List<MOCTCchaDto> moctCchaDtos){

        List<MOCTCchaDto> mergedList = mergeMoctCchaDtos(moctCchaDtos);
        return materialRequisitionService.updatemoctc(mergedList);
    }

    public List<MOCTCchaDto> mergeMoctCchaDtos(List<MOCTCchaDto> moctCchaDtos) {
        if (moctCchaDtos == null || moctCchaDtos.isEmpty()) {
            return Collections.emptyList();
        }

        // 以 tc001 + tc002 作为分组 key
        Map<String, List<MOCTCchaDto>> grouped = moctCchaDtos.stream()
                .collect(Collectors.groupingBy(dto -> dto.getTc001() + "_" + dto.getTc002()));

        // 合并每组数据
        return grouped.values().stream().map(group -> {
            MOCTCchaDto first = group.get(0); // 任意取一个
            List<MOCTEDto> mergedDetails = group.stream()
                    .filter(dto -> dto.getMocteDtos() != null)
                    .flatMap(dto -> dto.getMocteDtos().stream())
                    .collect(Collectors.toList());

            MOCTCchaDto merged = new MOCTCchaDto();
            merged.setCreateBy(first.getCreateBy());
            merged.setTc001(first.getTc001());
            merged.setTc002(first.getTc002());
            merged.setMocteDtos(mergedDetails);

            return merged;
        }).collect(Collectors.toList());
    }

//    @Recordable
//    @ApiOperation("根据扫机更新领料单")
//    @PostMapping("/updatemoctc")
//    public Result<List<MocteupdateVo>> updatemoctc(@RequestBody List<MOCTCchaDto> moctCchaDtos){
//        return materialRequisitionService.updatemoctc(moctCchaDtos);
//    }
//



//    @ApiOperation("领料出库-查询需要的领料的工单单身")
//    @PostMapping("/listWorkOrderBody")
//    public Result listWorkOrderBody(@RequestBody OrderDto orderDto){
//        PageHelper.startPage(orderDto.getPage(), orderDto.getPageSize());
//        List<WorkOrderBodyVo> list = moctaMapper.selectWorkOrderBodyVo(orderDto);
//        PageInfo<WorkOrderBodyVo> pageInfo = new PageInfo<>(list);
//        return Result.ok(pageInfo);
//    }

//    @ApiOperation("领料出库-新增领料单接口")
//    @PostMapping("/add")
//    public Result add(@RequestBody LldDto lldDto){
//        //领料单别根据传入的工单自动选成
//        return materialRequisitionService.add(lldDto);
//    }

//    @PostMapping("/getmoctc/{current}/{size}")
//    @ApiOperation("扫码根据单别单号获取领料单信息")
//    public Result<Map<String, MoctcVo>> getmoctc(@PathVariable Integer current, @PathVariable Integer size, @RequestBody MOCTCDto moctcDto){
//        if (moctcDto.getTc001().isEmpty() && moctcDto.getTc002().isEmpty()){
//            return Result.ok(new HashMap<>());
//        }
//        return moctcService.getmoctf(current,size,moctcDto);
//    }


    @ApiOperation("查看工作中心信息")
    @GetMapping("/listWorkCenter")
    public Result listWorkCenter(){
        List<InitCmsmdVo> list = cmsmdMapper.selectCmsmdVoList();
        return Result.ok(list);
    }

    @ApiOperation("查看订单信息")
    @GetMapping("/listWorkOrderHeader")
    public Result listWorkOrderHeader(@RequestParam(value = "工作中心") String gzzx){
        List<WorkOderHeaderVo> list = moctaMapper.selectWorkOrderHeaderVo(gzzx);
        return Result.ok(list);
    }





    @ApiOperation("工单入库-查询接口")
    @PostMapping("/queryMoInStorageSummary")
    public Result<?> queryMoInStorageSummary(@RequestBody String createBy){
        List<MoInStorageVo> moInStorage = moMapper.queryMoInStorageSummary(createBy, null);
        if (moInStorage.isEmpty()) {
            return Result.fail().message("没有已扫码数据");
        }
        return Result.ok(moInStorage).message("查询成功");
    }

    @ApiOperation("工单入库-扫码接口")
    @PostMapping("/scanBarcode")
    public Result<?> scanBarcode(@RequestBody MoInStorageDto dto){
        List<MoInStorageVo> list = moMapper.queryMoInStorageSummary(dto.getCreateBy(), dto.getBarcode());
        if (list.isEmpty()) {
            // 查询bm_barcode_detail
            MoInStorageVo moInStorage = moMapper.selectMoInStorage(dto);

            if (moInStorage == null){
                return Result.fail().message("该条码不存在！请确认需扫描条码而非派工单！");

            }
            if (moInStorage.getLotAtt30() != null && moInStorage.getLotAtt30().equals("4")) {
                return Result.fail().message("该条码已入库！");
            }
            MaxGxVo a =moMapper.getMaxGxNo(moInStorage);
//            if(!a.getMG003().equals(moInStorage.getMG003()) && !a.getMG007().equals(moInStorage.getMG007()) && !a.getMGD01().equals(moInStorage.getMGD01())){
//                return Result.fail().message("不是最后一道工序，不能产生入库单");
//            }
            String uuid = UUID.randomUUID().toString();
            moInStorage.setId(uuid);
            // 保存中间表
            moMapper.insertMoInStorageSummary(moInStorage, dto.getCreateBy());
            return Result.ok(moInStorage);
        }
        return Result.fail().message("该条码已在中间表！请勿重复扫码！");
    }

    /**
     * 工单入库 (调用远程e10的查询接口否则用不了)   工单生成生产入库单并生成条码
     * @param
     * @return
     */
//    @ApiOperation("工单入库(免-免生产入库申请)查询")
//    @PostMapping("/ListMoInStorage")
//    public Result ListMoInStorage(@RequestBody MoInStorageDto dto){
//        //查出该条码对应的工单号等信息作为生产入库单身信息、和部分单头信息
//        List<MoInStorageVo> list = moMapper.selectListMoInStorage(dto);
//        for(MoInStorageVo vo : list){
//            MaxGxVo a =moMapper.getMaxGxNo(vo);
//            if(!a.getMG003().equals(vo.getMG003()) && !a.getMG007().equals(vo.getMG007()) && !a.getMGD01().equals(vo.getMGD01())){
//                return Result.fail().message("不是最后一道工序，不能产生入库单");
//            }
//        }
//        return Result.ok(list);
//    }

    @ApiOperation("工单入库-提交-维护工单(已审核)->->生成维护生产入库单(已审核)")
    @Log("工单入库-提交-维护工单(已审核)->->生成维护生产入库单(已审核)")
    @PostMapping("/getMoInStorageSubmit")
//    @Transactional
    public Result MoInStorageSubmit(@RequestBody List<MoInStorageSubmitDto> dtoList,
                                    @RequestParam("createBy") String createBy){

        if (dtoList == null || dtoList.isEmpty()) {
            return Result.fail().message("提交参数不可为空！");
        }
        //工作中心不可为空
        if (dtoList.stream().anyMatch(dto -> dto.getWorkCenter() == null || dto.getWorkCenter().isEmpty())) {
            return Result.fail().message("工作中心不可为空！");
        }

        //或许员工所选入库时间
        String insertMoDate = dtoList.get(0).getInsertMoDate();


        // 1. 按工作中心（TA021）分组
        Map<String, List<MoInStorageSubmitDto>> groupedMap = dtoList.stream()
                .collect(Collectors.groupingBy(MoInStorageSubmitDto::getWorkCenter));

        for (Map.Entry<String, List<MoInStorageSubmitDto>> entry : groupedMap.entrySet()) {
            String workcenter = entry.getKey(); // 分组的工作中心
            List<MoInStorageSubmitDto> list = entry.getValue();

            String TF001 = "5810";
            if (insertMoDate == null || insertMoDate.isEmpty()) {
                String TF002 = commonService.getIdByType(TF001, "MOCTF"); // 入库单号
                String TF003 = new SimpleDateFormat("yyyyMMdd").format(new Date());
            }
            String TF002 = commonService.getIdByTypeQhMo(TF001, "MOCTF", insertMoDate); // 入库单号
            System.out.println("琪虎特选入库时间后的入库单号TF002:" + TF002);
            String TF003 = insertMoDate;

            String TF005 = "";
            All all = new All();
            all.setTF001(TF001);
            all.setTF002(TF002);
            all.setTF003(TF003);
            all.setTF004("1000"); // 工厂
            all.setTF006("N");    // 审核
            all.setTF011(workcenter); // 当前组的工作中心
            all.setTF013(createBy);
            all.setCompany("ZJQH");

            AtomicInteger seq = new AtomicInteger(1);

            // 用于存储分组后的结果，键为 docNo，值为合并后的 DTO
            Map<String, MOCTGDto> groupMap = new HashMap<>();
            //工单+库位，对应的库位中的数量
            Map<String, Double> docNoAndNUm = new HashMap<>();

            for (MoInStorageSubmitDto dto : list) {
                TF005 = dto.getStandardCol02(); // 备注中放组别
                String[] split = dto.getDocNo().split("-");

                if (split.length != 2) {
                    return Result.fail().message("工单号格式错误：" + dto.getDocNo());
                }

                String db = split[0]; // 工单别
                String dh = split[1]; // 工单号
                String docNo = dto.getDocNo(); // 完整工单号

                //判断该产品品号是否开启批号管理，开启则tg017批号是ta033，否则是”*“
                Invmb invmb = invmbMapper.selectOne(new QueryWrapper<Invmb>().eq("MB001", dto.getItemCode()));
                if (!invmb.getMb022().trim().equals("N")) {
                    String lotCode = moMapper.selectLotCode(db, dh);
                    dto.setLotCode(lotCode);
                } else {
                    dto.setLotCode("********************");

                }

                // 从分组中获取已存在的 MOCTGDto，不存在则创建新的
                MOCTGDto moctg = groupMap.computeIfAbsent(docNo, k -> {
                    MOCTGDto newMoctg = MOCTGDto.builder()
                            .TG001(TF001)
                            .TG002(TF002)
                            .TG003(String.format("%04d", seq.getAndIncrement())) // 生成序号
                            .TG004(dto.getItemCode())
                            .TG007(dto.getUnitNo())
                            .TG009(1.0)
                            .TG010(dto.getWarehouseCode())//仓库编号
                            .TG036(dto.getBinCode())//库位
                            .TG017(dto.getLotCode())//批号
                            .TG011(0.0) // 初始化为 0，后续累加
                            .TG013(0.0) // 初始化为 0，后续累加
                            .TG014(db)
                            .TG015(dh)
                            .TG016("1")
                            .TG020(dto.getStandardCol02())//备注中放组别
                            .TG022("N")
                            .build();
                    return newMoctg;
                });


                if (dto.getKwInfo() != null) {
                    for (KWAndNum kwAndNum : dto.getKwInfo()) {
                        String key = kwAndNum.getKw().trim() + "&" + docNo.trim();
                        if (docNoAndNUm.containsKey(key)) {
                            docNoAndNUm.put(key, docNoAndNUm.get(key) + kwAndNum.getNum());
                        } else {
                            docNoAndNUm.put(key, kwAndNum.getNum());
                        }
                    }
                }
                // 累加 matchQty 到 TG011 和 TG013
                moctg.setTG011(moctg.getTG011() + dto.getMatchQty());
                moctg.setTG013(moctg.getTG013() + dto.getMatchQty());
                List<KWAndNum> kwAndNumList = new ArrayList<>();
                for (Map.Entry<String, Double> entry2 : docNoAndNUm.entrySet()) {
                    KWAndNum kwAndNum = new KWAndNum();
                    String[] split1 = entry2.getKey().split("&");
                    kwAndNum.setKw(split1[0]);
                    kwAndNum.setNum(entry2.getValue());
                    kwAndNumList.add(kwAndNum);
                }
                moctg.setKwInfo(kwAndNumList);
            }


            all.setTF005(TF005);
            // 将分组结果转为列表
            List<MOCTGDto> moctgList = new ArrayList<>(groupMap.values());

            all.setMoctgList(moctgList);


            // 2. 生成生产入库单
            Result<?> result = moService.insertAll(all);
            System.out.println(result);
            if (result.getCode() != 200) {
//                return Result.fail().message("生成生产入库单失败，入库单号：" + TF001 + '-' + TF002 + result.getData());
                System.out.println("生成生产入库单失败，入库单号：" + TF001 + '-' + TF002 + result.getMessage());
                return Result.fail().message("生成生产入库单失败，入库单号：" + TF001 + '-' + TF002 + result.getMessage());
            }

            for (MOCTGDto newMoctg : moctgList) {

                // 3. 调用远程接口生成检验单
                Result<?> inspectResult = logisticsRemoteService.moInspection(TF001, TF002, newMoctg.getTG003());
                System.out.println(inspectResult);
                if (inspectResult.getCode() != 200) {
                    System.out.println(inspectResult.getData());
                    // 生产入库检验单生成失败后，删除生成的入库单
                    moctgMapper.delete(new QueryWrapper<Moctg>()
                            .eq("TG001", TF001)
                            .eq("TG002", TF002));
                    moctfMapper.delete(new QueryWrapper<Moctf>()
                            .eq("TF001", TF001)
                            .eq("TF002", TF002));
                    // 删除wms两表
                    wmsInvmlMapper.delete(new QueryWrapper<WmsInvml>()
                            .eq("ML001", newMoctg.getTG004())
                            .eq("ML002", newMoctg.getTG010())
                            .eq("ML003", newMoctg.getTG036())
                            .eq("ML004", newMoctg.getTG017()));
                    wmsInvlaMapper.delete(new QueryWrapper<WmsInvla>()
                            .eq("LA006", TF001)
                            .eq("LA007", TF002));

                    System.out.println("生成生产检验单失败，入库单号：" + TF001 + '-' + TF002 + inspectResult.getData());
                    return Result.fail("生成生产检验单失败，入库单号：" + TF001 + '-' + TF002 + inspectResult.getData());
                }


        }

                // 如需自动审核可打开此功能
//             Result<?> auditResult = logisticsRemoteService.auditOrder(TF001, TF002);


            }

        // 4. 易飞提交成功后，更新条码状态为已入库、删除中间表数据
        for (MoInStorageSubmitDto submitDto : dtoList) {
            moMapper.updateBarcodeWBU(submitDto);
        }
        moMapper.deleteMoInStorageSummaryByCreatBy(createBy);


        return Result.ok("已生成入库单、检验单，等待审核！");
    }

    @ApiOperation("工单入库-删除")
    @PostMapping("/deleteMoInStorageSummary")
    public Result<?> deleteMoInStorageSummary(@RequestBody String id){
        moMapper.deleteMoInStorageSummary(id);
        return Result.ok("删除成功").message("删除成功");
    }

    @ApiOperation("更改中间表仓库编号/库位")
    @PostMapping("/updateMoInStorageSummary")
    public Result<?> updateMoInStorageSummary(@RequestBody MoInstorageSummary dto){
        String binCode = dto.getBinCode();
        if (binCode != null && binCode.contains("#")) {
            return Result.fail().message("检测到条码格式，请扫描正确的库位！");
        }
        moMapper.updateMoInStorageSummary(dto);
        return Result.ok("更新成功").message("更新成功");
    }

    @ApiOperation("更改条码入库时间")
    @PostMapping("/moInStorageSummaryInsertMoDate")
    public Result<?> moInStorageSummaryInsertMoDate(@RequestBody List<String> idList, @RequestParam("insertMoDate") String insertMoDate){
        moMapper.moInStorageSummaryInsertMoDate(idList, insertMoDate);
        return Result.ok("已更新入库时间").message("更新成功");
    }

//
//    @ApiOperation("工单领料-查询需领料工单")
//    @PostMapping("/queryMoMaterial")
//    public Result<?> queryMoMaterial(MoMaterialDto dto){
//        // 1. 分页查询工单单头（InitMocta），仅对表头分页
////        PageHelper.startPage(dto.getPage(), dto.getPageSize());
//        List<InitMocta> moctaList = moMapper.queryMocta(dto);
////        PageInfo<InitMocta> moctaPageInfo = new PageInfo<>(moctaList);
//
//        if (moctaList.isEmpty()) {
//            return Result.fail().message("该时间段内无需领料工单！");
//        }
//
//        // 2. 提取表头中的TA001和TA002，用于批量查询表体
//        List<Map<String, String>> keyList = moctaList.stream().map(mocta -> {
//            Map<String, String> keyMap = new HashMap<>();
//            keyMap.put("ta001", mocta.getTa001()); // 工单单别
//            keyMap.put("ta002", mocta.getTa002()); // 工单单号
//            return keyMap;
//        }).collect(Collectors.toList());
//
//        // 3. 批量查询表体数据（根据TA001=TB001且TA002=TB002）
//        List<InitMoctb> allMoctbList = moMapper.queryMoctbByKeys(keyList);
//
//        // 4. 将表体数据按(TA001, TA002)分组，便于快速关联
//        Map<String, List<InitMoctb>> moctbGroupMap = allMoctbList.stream()
//                .collect(Collectors.groupingBy(
//                        moctb -> moctb.getTb001() + "-" + moctb.getTb002() // 用"TA001_TA002"作为分组键
//                ));
//
//        // 5. 组装MoMaterialVo列表（表头+对应的表体列表）
//        List<MoMaterialVo> moMaterialList = moctaList.stream().map(mocta -> {
//            MoMaterialVo vo = new MoMaterialVo();
//            vo.setMocta(mocta);
//            // 根据(TA001, TA002)获取对应的表体列表
//            String groupKey = mocta.getTa001() + "-" + mocta.getTa002();
//            List<InitMoctb> moctbList = moctbGroupMap.getOrDefault(groupKey, Collections.emptyList());
//            vo.setMoctb(moctbList); // 设置表体列表
//            return vo;
//        }).collect(Collectors.toList());
//
//        // 6. 构建分页结果（复用表头的分页信息）
////        PageInfo<MoMaterialVo> pageInfo = new PageInfo<>(moMaterialList);
////        pageInfo.setTotal(moctaPageInfo.getTotal()); // 总条数与表头一致
////        pageInfo.setPages(moctaPageInfo.getPages()); // 总页数与表头一致
////        return Result.ok(pageInfo).message("查询成功");
//
//        // 6. 将数据列表放入Map中
//        Map<String, Object> result = new HashMap<>();
//        result.put("data", moMaterialList);
//
//        return Result.ok(result).message("查询成功");
//    }
//
//    @ApiOperation("工单领料-查询领料单据性质")
//    @PostMapping("/queryMaterialDocType")
//    public Result queryMaterialDocType() throws UnknownHostException {
//        List<Cmsmq> csmsq = moMapper.queryMaterialDocType();
//        return Result.ok(csmsq).message("查询成功");
//    }
//
//    @ApiOperation("工单领料-生成领料单")
//    @PostMapping("/materialRequisition")
//    @Log("易飞-工单领料-生成领料单")
//    public Result materialRequisition(@RequestBody List<InitLldDto> dto) throws UnknownHostException {
//        if (dto == null || dto.isEmpty()) {
//            return Result.fail().message("提交参数不可为空！");
//        }
//        // 1. 根据来源单别和来源单号进行分组
//        Map<String, List<InitLldDto>> groupedLldMap = dto.stream()
//                .collect(Collectors.groupingBy(initLldDto -> initLldDto.getTC019() + "-" + initLldDto.getTC020()));
//
//        // 用于存储生成的领料单结果
//        List<Result> resultList = new ArrayList<>();
//
//        // 遍历分组后的单头列表
//        for (Map.Entry<String, List<InitLldDto>> entry : groupedLldMap.entrySet()) {
//            String groupKey = entry.getKey();
//            List<InitLldDto> groupedLldList = entry.getValue();
//
//            // 确保同一工单单别和单号的数据只能有一条单头记录
//            if (groupedLldList.size() > 1) {
//                return Result.fail().message("同一工单单别和单号的数据应该只有一条单头记录！");
//            }
//
//            InitLldDto initLldDto = groupedLldList.get(0);
//
//            // 2. 校验单头参数
//            if (initLldDto == null) {
//                return Result.fail().message("单头参数不可为空！");
//            }
//            if (initLldDto.getTC005() == null) {
//                return Result.fail().message("工作中心不可为空！");
//            }
//
//            // 3. 获取单头中的工单单别、单号
//            String modb = initLldDto.getTC019(); // 单头工单单别
//            String modh = initLldDto.getTC020(); // 单头工单单号
//            if (StringUtils.isEmpty(modb) || StringUtils.isEmpty(modh)) {
//                return Result.fail().message("单头工单单别或单号不可为空！");
//            }
//
//            List<InitLldList> detailList = initLldDto.getTeList(); // 领料工单列表
//            if (detailList == null || detailList.isEmpty()) {
//                return Result.fail().message("领料单单身数据不可为空！");
//            }
//
//            // 4. 校验单身与单头的工单单别、单号是否一致
//            for (InitLldList detail : detailList) {
//                String detailModb = detail.getTE011(); // 单身工单单别
//                String detailModh = detail.getTE012(); // 单身工单单号
//                if (!modb.equals(detailModb) || !modh.equals(detailModh)) {
//                    return Result.fail().message(String.format("单身序号%s的工单单别/单号与单头不一致，请检查！", detail.getTE003()));
//                }
//            }
//
//            // 5. 领料单别单号
//            String TC001 = initLldDto.getTC001();
//            String TC002 = commonService.getIdByType(TC001, "MOCTC");
//            String TC004 = "1000";
//            String company = "ZJQH";
//            initLldDto.setTC002(TC002);
//            initLldDto.setTC004(TC004);
//            initLldDto.setCompany(company);
//            // 6. 设置领料单身中单别单号
//            for (InitLldList detail : detailList) {
//                detail.setTE002(TC002);
//            }
//
//            // 7. 生成领料单
//            Result result = moService.saveMaterialRequisition(initLldDto);
//            resultList.add(result);
//        }
//
//        // 8. 返回结果
//        if (resultList.stream().anyMatch(result -> !result.getCode().equals(200))) {
//            return Result.fail().message("部分领料单生成失败！");
//        }
//
//        // 9. 构建返回的Map
//        Map<String, Object> result = new HashMap<>();
//        result.put("moMaterialMap", groupedLldMap);
//
//        return Result.ok(result).message("领料单生成成功！");
//    }
//


}
